package day28;

// 单链表部分反转:n长度、val【】结点值、L反转左节点、R反转右节点

// 不会写！！

/* 有问题！！
// 参考答案后进行重写：

import java.util.Scanner;

public class Main1 {
    // 定义一个结点
    static class Node {
        public int val;
        public Node next; // 单链表只有next，没有prev
        public Node (int val) {
            this.val = val;
        }
    }

    public static void main(String[] args) {
        // 开始进行输入：
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            // 定义头结点
            Node head = new Node(-1);  // 头结点会一直存在且一直为-1，只是类似于一个标记位
            Node cur = head;

            int n = in.nextInt();
            // 输入结点
            for (int i = 0; i < n; i++) {
                cur.next = new Node(in.nextInt());
                cur = cur.next;
            }
            //输入反转首尾
            int l = in.nextInt();
            int r = in.nextInt();

            // 开始进行反转操作
            // 来到这儿，此时cur到了最后一个位置，先把cur移到头结点位置
            cur = head;
            // 然后开始向后遍历：
            int k = 1; // 此处只是为了和l、r做对比（l、r是指位置，而不是结点值！注意区分）
            while (cur != null) {
                if(k == l) {
                    Node curNext = cur.next;
                    Node curNTmp = cur.next;
                    Node prev = null; // 用来记录之前的节点

                    while (curNext!=null && k<=r) {
                        // 记录下一个结点的再下一个结点
                        Node nextMore = curNext.next;
                        // 记录前一个结点
                        curNTmp.next = prev;
                        prev = curNTmp;
                        curNTmp = nextMore;
                        k++;
                    }
                    // 出来，说明 要么走到最后了，要么是已经走到右端了
                    cur.next = prev;
                    curNTmp.next = curNext;
                } else {
                    // 说明还没找到最开始的反转位置，那就一直往后
                    cur = cur.next;
                    k++;
                }
            }

            // 开始操作输出
            StringBuilder builder = new StringBuilder();
            cur = head.next; // 标志位之后是正式开端
            while (cur != null) {
                // 注意：输出需要的是结点值
                builder.append(cur.val).append(" ");
                cur = cur.next;
            }
            System.out.println(builder);
        }
    }

}*/



// 重新：还是存在问题！！

import java.util.*;

public class Main1 {
    // 定义一个结点
    static class Node {
        public int val;
        public Node next; // 单链表只有next，没有prev
        public Node (int val) {
            this.val = val;
        }
    }
    

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            Node head = create(n); //真正头结点
            int left = scanner.nextInt();
            int right = scanner.nextInt();
            head = partReserve(head, left, right);
            print(head);
        }
        }
       
    private  static void print(Node head){
        // 遍历打印结点值
        while(head!=null){
            System.out.print(head.val+" ");
            head = head.next;
        }
    }
    
    private static Node partReserve(Node head,int left,int right) {
        if (head == null || left == right) {
            return head;
        }
        
        //start指向left结点的前驱结点
        Node ph = new Node(-1); // 假定的标志头
        ph.next = head;
        Node start = ph;
        int x=left;
        while (x-- > 1) {
            //start走到left-1位置
            start = start.next;
        }

        Node cur = start.next;
        Node pHead = cur; // 作为反转头
        //cur 指向第left个结点
        Node curNext = cur.next;

        while (curNext != null && left < right) { // 注意循环条件！！
            Node tmp = curNext.next;
            // 从前往后开始指向倒转
            curNext.next = cur;
            cur = curNext;
            curNext = tmp;
            left++;
        }
        // 说明此时只差最后一个倒转：
        start.next = cur;
        pHead.next = curNext;
        return ph.next; // 真的反转后head
    }
    private static Node create(int n) {
        Scanner scanner = new Scanner(System.in);
        Node head = new Node(-1);
        Node cur = head;
        while (n-- > 0) { // 先用后减
            cur.next = new Node(scanner.nextInt());
            cur = cur.next;
        }
        return head.next; // 真正的输入开始结点！
    }
}
